package agentes;

import cenario.Cenario;
import java.util.ArrayList;

public class Zumbi extends Agente {

    public Zumbi(int column, int row) {
        super(column, row);
    }

    public void olhadinhaAoRedor() {
        int column = this.getColumn();
        int row = this.getRow();
        
        //agentes encontrados
        ArrayList<Zumbi> zumbis = new ArrayList<Zumbi>();
        ArrayList<Agente> pessoasEExterminadores = new ArrayList<Agente>();

        //procura numa distancia de 2 
        
        int columnMin = (column-2) >= 0 ? column-2 : 0; 
        int rowMin = (row-2) >= 0 ? row-2 : 0;        
        int columnMax = (column+2) <= Cenario.MAXCOLUMN ? column+2 : Cenario.MAXCOLUMN;
        int rowMax = (row+2) <= Cenario.MAXROW ? row+2 : Cenario.MAXROW;
                
        for (int indexCol = columnMin ; indexCol <= columnMax; indexCol++) {
            for (int indexRow = rowMin; indexRow <= rowMax; indexRow++) {
                Agente agente = Cenario.getAgente(indexCol, indexRow);
                if (agente != null) {
                    AgenteTypeEnum agenteS = whoAmI(agente);
                    //adiciona encontrados nos arrays
                    switch (agenteS) {
                        case ZUMBI:
                            zumbis.add((Zumbi) agente);
                            break;

                        case PESSOA:
                            pessoasEExterminadores.add(agente);
                            break;

                        case EXTERMINADOR:
                            pessoasEExterminadores.add(agente);
                            break;
                    }
                }
            }
        }

        Agente maisPerto;
        //se encontrou alguem, ve quem eh
        if (pessoasEExterminadores.size() > 0) {
            maisPerto = whoIsNear(pessoasEExterminadores);
            
            if(candidateForEating(maisPerto)!=null){
                EATHIM(maisPerto);
                return;
            }

            //ve de qual lado o cara ta e vai em direcao a ele
            int distanciaColuna = Math.abs(maisPerto.getColumn() - this.getColumn());
            int distanciaLinha = Math.abs(maisPerto.getRow() - this.getRow());

            if (distanciaColuna > distanciaLinha) {

                if (maisPerto.getColumn() > this.getColumn()) {
                    this.andarDireita();
                } else {
                    this.andarEsquerda();
                }
            } else {
                if (maisPerto.getRow() > this.getRow()) {
                    this.andarBaixo();
                } else {
                    this.andarCima();
                }
            }
        }
    }

    /*
     * Retorna o tipo de agente
     */
    public static AgenteTypeEnum whoAmI(Object object) {
        if (object instanceof Zumbi) {
            return AgenteTypeEnum.ZUMBI;
        } else if (object instanceof Pessoa) {
        	return AgenteTypeEnum.PESSOA;
        } else if (object instanceof Exterminador) {
        	return AgenteTypeEnum.EXTERMINADOR;
        } else {
            return null;
        }
    }

    /*
     * Retorna qual agente ta mais perto
     */
    public Agente whoIsNear(ArrayList<Agente> agentesPerto) {
        Agente maisPerto = agentesPerto.get(0);
        int distancia = Math.abs(this.getColumn() - agentesPerto.get(0).getColumn())
                + Math.abs(this.getRow() - agentesPerto.get(0).getRow());

        for (Agente agente : agentesPerto) {
            int distancia2 = Math.abs(this.getColumn() - agente.getColumn())
                    + Math.abs(this.getRow() - agente.getRow());

            if (distancia2 < distancia) {
                maisPerto = agente;
            }
        }

        return maisPerto;
    }
    
    public Agente candidateForEating(ArrayList<Agente> candidatos){
        Agente found = null;
        
        for(Agente candidato: candidatos){
            if(Math.abs((candidato.getColumn()) - (this.getColumn())) +
                    Math.abs((candidato.getRow()) - (this.getRow())) == 1){
                found = candidato;
            }
        }
        return found;
    }
    
    public Agente candidateForEating(Agente candidato){
            if(Math.abs((candidato.getColumn()) - (this.getColumn())) +
                    Math.abs((candidato.getRow()) - (this.getRow())) == 1){
                return candidato;
            }
        return null;
    }
    
    public void EATHIM(Agente agente){
        Zumbi zumbi = new Zumbi(agente.getColumn(), agente.getRow());
        Cenario.setAgente(zumbi, agente.getColumn(), agente.getRow());
    }
}
